Best Tools for JAVA

home *** CD-ROM | disk | FTP | other *** search

/ Best Tools for JAVA / Best Tools for JAVA.iso / JAVA_ALL / IDE / SUBARTIC / RELEASE.ZIP / sub_arctic / constraints / op1_impl.java < prev next >

Wrap

Java Source | 1996-10-04 | 13.5 KB | 391 lines

package sub_arctic.constraints; import sub_arctic.lib.interactor; import sub_arctic.lib.interactor_consts; import sub_arctic.lib.manager; import sub_arctic.lib.sub_arctic_error; import java.util.Vector; /** * Constraint implementation class to provide encoding for standard 1 operand * lightweight constraint. This object takes 1 std_objpart_encoding object * representing an operand, along with a signed 16 bit value to provide a * constant to the function. * * 1 operand constraints are encoded as: * <pre> * 16 6 5 5 * KKKKKKKKKKKKKKKK AAAAAA 00001 00001 31 1 operand operations * ... [K is 16 bit signed] * KKKKKKKKKKKKKKKK AAAAAA 11111 00001 * </pre> * where KKK represents a 16 bit signed constant, AAA represents the parameter * objects, and XXX represents bits used to encode an op code. * * @author Scott Hudson */ public class op1_impl implements std_encoding_consts { /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /** * Create a standard constraint given an op_code, an obj/part designator, * and a constant. * * @param int op_code op code value for this operation. * @param std_objpart_encoding op1 designator for operand 1 * @param short K value for 16 bit signed constant */ public static std_constraint create( int op_code, std_objpart_encoding op1, short K) { return new std_constraint(encode(op_code, op1, K), op1.orientation()); } //had: //* @exception bad_constraint if part of the encoding is out of range. /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /** * Do an encoding given an op_code, an obj/part designator, and a constant. * * @param int op_code op code value for this operation. * @param std_objpart_encoding op1 designator for operand 1 * @param short K value for 16 bit signed constant */ public static int encode(int op_code, std_objpart_encoding op1, short K) { if (op_code < OP1_MIN || op_code > OP1_MAX) throw new sub_arctic_error( "Unrecognized op code (" + op_code + ") used for 1 op constraint"); return (((int)K)<<16) | ((op1.encoding() & OBJPART_MASK) << 10) | ((op_code<<OP1_SHIFT) & OP1_MASK) | OP1_LOBITS; } //had: //* @exception bad_constraint if part of the encoding is out of range. /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /** * Decode op_code from the given encoding. Note: we assume this is * already known to be a 1-op constraint. If not, the results will be * wrong. * * @param int enc the encoding for the constraint. */ public static int op_code(int enc) { return (enc & OP1_MASK) >> OP1_SHIFT; } /** * Decode first operand from given encoding. Note: we assume this is * already known to be a 1-op constraint. If not, the results will be * wrong. * * @param int enc the encoding for the constraint. */ public static int op1(int enc) { return (enc >> 10) & OBJPART_MASK; } /** Decode constant from given encoding. Note: we assume this is * already known to be a 1-op constraint. If not, the results will be * wrong. * * @param int enc the encoding for the constraint. */ public static short const_val(int enc) { return (short)((enc>>16) & 0xffff); } /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /* Part constants copied over from interactor_consts for convenience. */ public static final int X = interactor_consts.X; public static final int Y = interactor_consts.Y; public static final int W = interactor_consts.W; public static final int H = interactor_consts.H; /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /** * Evaluate an encoded constraint function given its operand and constant * values. We assume here that it is has already been determined that * the constraint is a 1-op constraint. * * @param int enc the encoding from the constraint * @param interactor constr_obj the object being constrained * @param int val1 value of first operand * @param int cnst_val value of constant parameter * @param int orient orientation of the constraint (should be * HORIZONTAL or VERTICAL). * @return int the result of the evaluation */ public static int eval_fun( int enc, interactor constr_obj, int val1, int cnst_val, int orient) { interactor par; int self_wh; /* sanity check */ if (constr_obj == null) throw new sub_arctic_error("Null constrained object passed to " + "op1_impl.eval_fun()"); /* execute code for the encoded function */ switch(op_code(enc)) { case OP_self_fun1: /* use the object's custom_fun1() to compute the value */ return constr_obj.custom_fun1(val1, cnst_val); case OP_parent_fun1: /* get the parent and call its custom_fun1() */ par = constr_obj.parent(); if (par != null) return par.custom_fun1(val1, cnst_val); else return 0; case OP_not_mask: return ~val1 & (cnst_val | 0xffff0000); case OP_mask: return val1 & (cnst_val | 0xffff0000); case OP_centered: /* get self.wh */ if (orient == HORIZONTAL) self_wh = constr_obj.get_part(W); else self_wh = constr_obj.get_part(H); /* compute and return value */ return (val1 - self_wh)/2 + cnst_val; case OP_offset: return val1 + cnst_val; case OP_far_edge_just: /* get self.wh */ if (orient == HORIZONTAL) self_wh = constr_obj.get_part(W); else self_wh = constr_obj.get_part(H); /* compute and return value */ return val1 - self_wh - cnst_val; default: /* something is wrong if we get here */ throw new sub_arctic_error("Improperly encoded constraint found in "+ "op1_impl.eval_fun()"); } } //had: //* @exception bad_value if the encoding, or constrained object/part are //* malformed /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /** * Evaluate an encoded constraint applied to the given part of the given * object. We assume here that it it has already been determined that * the constraint is a 1-op constraint. * * @param int enc the encoding from the constraint * @param interactor constr_obj the object being constrained * @param int constr_part the part being constrained * @param int orient the orientation of the constraint * @return int the result of the evaluation */ public static int eval( int enc, interactor constr_obj, int constr_part, int orient) { int cnst_val, val1; /* sanity check */ if (constr_obj == null) throw new sub_arctic_error("Null constrained object passed to " + "op1_impl.eval()"); /* extract the constant */ cnst_val = const_val(enc); /* get the value for the single operand */ val1 = std_constraint_impl.the_impl().fetch_value( op1(enc), constr_obj, orient); /* compute the value */ return eval_fun(enc, constr_obj, val1, cnst_val, orient); } //had: //* @exception bad_value if the encoding, or constrained object/part are //* malformed /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /** Test whether the given encoded constraint (constraining the given * object) depends on the indicated object and part (expressed relative * to it). Here we assume that the encoding is already known to contain * a 1-op constraint. * * @param int enc The encoding for the constraint. * @param interactor constr_obj The object the constraint is attached to * @param int test_which_obj The object we are asking about. This * can be one of the values OBJCODE_SELF, * OBJCODE_PARENT, OBJCODE_SOME_CHILD, * OBJCODE_PREV_SIBLING, or * OBJCODE_NEXT_SIBLING. * @param int test_which_part The part we are asking about. * @param int nth_child for SOME_CHILD, this provides the index * of the child (and is ignored otherwise). * @param int orient Orientation of the constraint. This * should be HORIZONTAL or VERTICAL. * @return boolean whether the given constraint depends upon the given value */ public static boolean depends_on( int enc, interactor constr_obj, int which_obj, int which_part, int nth_child, int orient) { int op; /* extract op code to look for special case implicit operands */ op = op_code(enc); /* only special cases here are centered and far_edge_just which have * implicit self.wh */ if ((op == OP_centered || op == OP_far_edge_just) && which_obj == OBJCODE_SELF) { if (orient == HORIZONTAL) { if (which_part == W) return true; } else { if (which_part == H) return true; } } /* now have a look at the operand dependency */ op = op1(enc); return std_constraint_impl.the_impl().part_depends_on(op, constr_obj, which_obj, which_part, nth_child, orient); } //had: //* @exception bad_value if one of the parameters has an unrecognized value /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /** * Extract the set of objects/parts that a constraint depends on. This * produces a Vector with pairs of entries, the first being an interactor, * and the second being an Integer which is the part number of that * interactor that is depended upon. * * Here we assume that this is a 1 operand constraint. * * @param int enc encoding value for the constraint in question. * @param interactor constr_obj the object the constraint is attached to * (hence its referents are relative to). * @param int orient Orientation of the constraint. This * should be HORIZONTAL or VERTICAL. * @return Vector containing pairs of objects, the first being an interactor * which is depended upon, and the second being an Integer * giving the part number of the part depended upon. */ public static Vector mk_depend_list(int enc, interactor constr_obj,int orient) { int op; Vector result; /* do the implicit special cases */ result = mk_implicit_depend_list(enc, constr_obj, orient); /* extract the operand and process that */ op = op1(enc); std_constraint_impl.the_impl() .add_depend_obj_part(result, op, constr_obj, orient); return result; } //had: //* @exception bad_value if one of the parameters has an unrecognized value /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ /** * Extract the set of objects/parts that a particular constraint function * implicitly depends on. This produces a Vector with pairs of entries, the * first being an interactor, and the second being an Integer which is the * part number of that interactor that is depended upon. * * @param int enc encoding value for the constraint in question. * @param interactor constr_obj the object the constraint is attached to * (hence its referents are relative to). * @param int orient Orientation of the constraint. This * should be HORIZONTAL or VERTICAL. * @return Vector containing pairs of objects, the first being an interactor * which is depended upon, and the second being an Integer * giving the part number of the part depended upon. */ public static Vector mk_implicit_depend_list( int enc, interactor constr_obj,int orient) { int op; Vector result = new Vector(6); /* extract operand. */ op = op_code(enc); /* only special cases are OP_centered and OP_far_edge_just which * implicitly depend on self.wh. */ if (op == OP_centered || op == OP_far_edge_just) { result.addElement(constr_obj); if (orient == HORIZONTAL) result.addElement(new Integer(W)); else result.addElement(new Integer(H)); } return result; } /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ } /*=========================== COPYRIGHT NOTICE =========================== This file is part of the subArctic user interface toolkit. Copyright (c) 1996 Scott Hudson and Ian Smith All rights reserved. The subArctic system is freely available for most uses under the terms and conditions described in http://www.cc.gatech.edu/gvu/ui/sub_arctic/sub_arctic/doc/usage.html and appearing in full in the lib/interactor.java source file. The current release and additional information about this software can be found starting at: http://www.cc.gatech.edu/gvu/ui/sub_arctic/ ========================================================================*/